SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Dangling pointer</title>

</head>

Dangling pointer

</h1>

</header>

Dangling pointers and wild pointers in <a href="Computer_programming" title="Computer programming">computer programming</a> are <a href="Data_pointer" class="mw-redirect" title="Data pointer">pointers</a> that do not point to a valid object of the appropriate type. These are special cases of <a href="Memory_safety" title="Memory safety">memory safety</a> violations. More generally, dangling references and wild references are <a href="Reference_(computer_science)" title="Reference (computer science)">references</a> that do not resolve to a valid destination.

Dangling pointers arise during <a href="Object_destruction" class="mw-redirect" title="Object destruction">object destruction</a>, when an object that is pointed to by a given pointer is deleted or deallocated, without modifying the value of that said pointer, so that the pointer still points to the memory location of the deallocated memory. The system may reallocate the previously freed memory, and if the program then <a href="Dereference_operator" class="mw-redirect" title="Dereference operator">dereferences</a> the (now) dangling pointer, <a href="Undefined_behavior" title="Undefined behavior">unpredictable behavior</a> may result, as the memory may now contain completely different data. If the program writes to memory referenced by a dangling pointer, a silent corruption of unrelated data may result, leading to subtle <a href="Software_bug" title="Software bug">bugs</a> that can be extremely difficult to find. If the memory has been reallocated to another process, then attempting to dereference the dangling pointer can cause <a href="Segmentation_fault" title="Segmentation fault">segmentation faults</a> (UNIX, Linux) or <a href="General_protection_fault" title="General protection fault">general protection faults</a> (Windows). If the program has sufficient privileges to allow it to overwrite the bookkeeping data used by the kernel's memory allocator, the corruption can cause system instabilities. In <a href="Object-oriented_language" class="mw-redirect" title="Object-oriented language">object-oriented languages</a> with <a href="Garbage_collection_(computer_science)" title="Garbage collection (computer science)">garbage collection</a>, dangling references are prevented by only destroying objects that are unreachable, meaning they do not have any incoming pointers; this is ensured either by tracing or <a href="Reference_counting" title="Reference counting">reference counting</a>. However, a <a href="Finalizer" title="Finalizer">finalizer</a> may create new references to an object, requiring <a href="Object_resurrection" title="Object resurrection">object resurrection</a> to prevent a dangling reference.

Wild pointers, also called uninitialized pointers, arise when a pointer is used prior to initialization to some known state, which is possible in some programming languages. They show the same erratic behavior as dangling pointers, though they are less likely to stay undetected because many compilers will raise a warning at compile time if declared variables are accessed before being initialized.<a href="#cite_note-1">[1]</a>

<div class="mw-heading mw-heading2"><h2 id="Cause_of_dangling_pointers">Cause of dangling pointers</h2></div>

In many languages (e.g., the <a href="C_(programming_language)" title="C (programming language)">C programming language</a>) deleting an object from memory explicitly or by destroying the <a href="Stack_frame" class="mw-redirect" title="Stack frame">stack frame</a> on return does not alter associated pointers. The pointer still points to the same location in memory even though that location may now be used for other purposes.

A straightforward example is shown below:

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>{

char *dp = NULL;

/* ... */

{

char c;

dp = &c;

}

/* c falls out of scope */

/* dp is now a dangling pointer */

}

</pre></div>

If the operating system is able to detect run-time references to <a href="Null_pointer" title="Null pointer">null pointers</a>, a solution to the above is to assign 0 (null) to dp immediately before the inner block is exited. Another solution would be to somehow guarantee dp is not used again without further initialization.

Another frequent source of dangling pointers is a jumbled combination of <code>malloc()</code> and <code>free()</code> library calls: a pointer becomes dangling when the block of memory it points to is freed. As with the previous example one way to avoid this is to make sure to reset the pointer to null after freeing its reference—as demonstrated below.

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>#include <stdlib.h>

void func()

{

/* ... */

free(dp); /* dp now becomes a dangling pointer */

dp = NULL; /* dp is no longer dangling */

/* ... */

}

</pre></div>

An all too common misstep is returning addresses of a stack-allocated local variable: once a called function returns, the space for these variables gets deallocated and technically they have "garbage values".

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>int *func(void)

{

int num = 1234;

/* ... */

return &num;

}

</pre></div>

Attempts to read from the pointer may still return the correct value (1234) for a while after calling <code>func</code>, but any functions called thereafter may overwrite the stack storage allocated for <code>num</code> with other values and the pointer would no longer work correctly. If a pointer to <code>num</code> must be returned, <code>num</code> must have scope beyond the function—it might be declared as <code><a href="Static_variable" title="Static variable">static</a></code>.

<div class="mw-heading mw-heading2"><h2 id="Manual_deallocation_without_dangling_reference">Manual deallocation without dangling reference</h2></div>

Antoni Kreczmar (1945–1996) has created a complete object management system which is free of dangling reference phenomenon.<a href="#cite_note-2">[2]</a> A similar approach was proposed by Fisher and LeBlanc<a href="#cite_note-Fisher-3">[3]</a> under the name <a href="Locks-and-keys_(computing)" title="Locks-and-keys (computing)">Locks-and-keys</a>.

<div class="mw-heading mw-heading2"><h2 id="Cause_of_wild_pointers">Cause of wild pointers</h2></div>

Wild pointers are created by omitting necessary initialization prior to first use. Thus, strictly speaking, every pointer in programming languages which do not enforce initialization begins as a wild pointer.

This most often occurs due to jumping over the initialization, not by omitting it. Most compilers are able to warn about this.

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>int f(int i)

{

char *dp; /* dp is a wild pointer */

static char *scp; /* scp is not a wild pointer:

* static variables are initialized to 0

* at start and retain their values from

* the last call afterwards.

* Using this feature may be considered bad

* style if not commented */

}

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Security_holes_involving_dangling_pointers">Security holes involving dangling pointers</h2></div>

Like <a href="Buffer_overflow" title="Buffer overflow">buffer-overflow</a> bugs, dangling/wild pointer bugs frequently become security holes. For example, if the pointer is used to make a <a href="Virtual_function" title="Virtual function">virtual function</a> call, a different address (possibly pointing at exploit code) may be called due to the <a href="Vtable" class="mw-redirect" title="Vtable">vtable</a> pointer being overwritten. Alternatively, if the pointer is used for writing to memory, some other data structure may be corrupted. Even if the memory is only read once the pointer becomes dangling, it can lead to information leaks (if interesting data is put in the next structure allocated there) or to <a href="Privilege_escalation" title="Privilege escalation">privilege escalation</a> (if the now-invalid memory is used in security checks). When a dangling pointer is used after it has been freed without allocating a new chunk of memory to it, this becomes known as a "use after free" vulnerability.<a href="#cite_note-4">[4]</a> For example, <a href="CVE_(identifier)" class="mw-redirect" title="CVE (identifier)">CVE</a>-<style data-mw-deduplicate="TemplateStyles:r1238218222">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><a rel="nofollow" class="external text" href="https://nvd.nist.gov/vuln/detail/CVE-2014-1776">2014-1776</a> is a use-after-free vulnerability in Microsoft Internet Explorer 6 through 11<a href="#cite_note-5">[5]</a> being used by <a href="Zero-day_attack" class="mw-redirect" title="Zero-day attack">zero-day attacks</a> by an <a href="Advanced_persistent_threat" title="Advanced persistent threat">advanced persistent threat</a>.<a href="#cite_note-6">[6]</a>

<div class="mw-heading mw-heading2"><h2 id="Avoiding_dangling_pointer_errors">Avoiding dangling pointer errors</h2></div>

In C, the simplest technique is to implement an alternative version of the <code>free()</code> (or alike) function which guarantees the reset of the pointer. However, this technique will not clear other pointer variables which may contain a copy of the pointer.

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>#include <assert.h>

#include <stdlib.h>

/* Alternative version for 'free()' */

static void safefree(void **pp)

{

/* in debug mode, abort if pp is NULL */

assert(pp);

/* free(NULL) works properly, so no check is required besides the assert in debug mode */

free(*pp); /* deallocate chunk, note that free(NULL) is valid */

*pp = NULL; /* reset original pointer */

}

int f(int i)

{

char *p = NULL, *p2;

p = malloc(1000); /* get a chunk */

p2 = p; /* copy the pointer */

/* use the chunk here */

safefree((void **)&p); /* safety freeing; does not affect p2 variable */

safefree((void **)&p); /* this second call won't fail as p is reset to NULL */

char c = *p2; /* p2 is still a dangling pointer, so this is undefined behavior. */

return i + c;

}

</pre></div>

The alternative version can be used even to guarantee the validity of an empty pointer before calling <code>malloc()</code>:

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>safefree(&p); /* I'm not sure if chunk has been released */

p = malloc(1000); /* allocate now */

</pre></div>

These uses can be masked through <code>#define</code> directives to construct useful macros (a common one being <code>#define XFREE(ptr) safefree((void **)&(ptr))</code>), creating something like a metalanguage or can be embedded into a tool library apart. In every case, programmers using this technique should use the safe versions in every instance where <code>free()</code> would be used; failing in doing so leads again to the problem. Also, this solution is limited to the scope of a single program or project, and should be properly documented.

Among more structured solutions, a popular technique to avoid dangling pointers in C++ is to use <a href="Smart_pointer" title="Smart pointer">smart pointers</a>. A smart pointer typically uses <a href="Reference_counting" title="Reference counting">reference counting</a> to reclaim objects. Some other techniques include the <a href="Tombstone_(programming)" title="Tombstone (programming)">tombstones</a> method and the <a href="Locks-and-keys" class="mw-redirect" title="Locks-and-keys">locks-and-keys</a> method.<a href="#cite_note-Fisher-3">[3]</a>

Another approach is to use the <a href="Boehm_garbage_collector" title="Boehm garbage collector">Boehm garbage collector</a>, a conservative <a href="Garbage_collection_(computer_science)" title="Garbage collection (computer science)">garbage collector</a> that replaces standard memory allocation functions in C and <a href="C%2B%2B" title="C++">C++</a> with a garbage collector. This approach completely eliminates dangling pointer errors by disabling frees, and reclaiming objects by garbage collection.

Another approach is to use a system such as <a href="Capability_Hardware_Enhanced_RISC_Instructions" title="Capability Hardware Enhanced RISC Instructions">CHERI</a>, which stores pointers with additional metadata which may prevent invalid accesses by including lifetime information in pointers. CHERI typically requires support in the CPU to conduct these additional checks.

In languages like Java, dangling pointers cannot occur because there is no mechanism to explicitly deallocate memory. Rather, the garbage collector may deallocate memory, but only when the object is no longer reachable from any references.

In the language <a href="Rust_(programming_language)" title="Rust (programming language)">Rust</a>, the <a href="Type_system" title="Type system">type system</a> has been extended to include also the variables lifetimes and <a href="Resource_acquisition_is_initialization" title="Resource acquisition is initialization">resource acquisition is initialization</a>. Unless one disables the features of the language, dangling pointers will be caught at compile time and reported as programming errors.

<div class="mw-heading mw-heading2"><h2 id="Dangling_pointer_detection">Dangling pointer detection</h2></div>

To expose dangling pointer errors, one common programming technique is to set pointers to the <a href="Null_pointer" title="Null pointer">null pointer</a> or to an invalid address once the storage they point to has been released. When the null pointer is dereferenced (in most languages) the program will immediately terminate—there is no potential for data corruption or unpredictable behavior. This makes the underlying programming mistake easier to find and resolve. This technique does not help when there are multiple copies of the pointer.

Some debuggers will automatically overwrite and destroy data that has been freed, usually with a specific pattern, such as <code><a href="0xDEADBEEF" class="mw-redirect" title="0xDEADBEEF">0xDEADBEEF</a></code> (Microsoft's Visual C/C++ debugger, for example, uses <code>0xCC</code>, <code>0xCD</code> or <code>0xDD</code> depending on what has been freed<a href="#cite_note-7">[7]</a>). This usually prevents the data from being reused by making it useless and also very prominent (the pattern serves to show the programmer that the memory has already been freed).

Tools such as <a href="Polyspace" title="Polyspace">Polyspace</a>, <a href="Rogue_Wave_Software" title="Rogue Wave Software">TotalView</a>, <a href="Valgrind" title="Valgrind">Valgrind</a>, Mudflap,<a href="#cite_note-8">[8]</a> <a href="AddressSanitizer" class="mw-redirect" title="AddressSanitizer">AddressSanitizer</a>, or tools based on <a href="LLVM" title="LLVM">LLVM</a><a href="#cite_note-9">[9]</a> can also be used to detect uses of dangling pointers.

Other tools (<a rel="nofollow" class="external text" href="http://www.cis.upenn.edu/acg/softbound/">SoftBound</a>, <a href="Insure%2B%2B" title="Insure++">Insure++</a>, and <a rel="nofollow" class="external text" href="http://www.semanticdesigns.com/Products/MemorySafety">CheckPointer</a>) instrument the source code to collect and track legitimate values for pointers ("metadata") and check each pointer access against the metadata for validity.

Another strategy, when suspecting a small set of classes, is to temporarily make all their member functions <a href="Virtual_method" class="mw-redirect" title="Virtual method">virtual</a>: after the class instance has been destructed/freed, its pointer to the <a href="Virtual_method_table" title="Virtual method table">Virtual Method Table</a> is set to <code>NULL</code>, and any call to a member function will crash the program and it will show the guilty code in the debugger.

The <a href="AArch64" title="AArch64">ARM64</a> memory tagging extension (MTE) - disabled by default on Linux systems, but can be enabled on <a href="Android_16" title="Android 16">Android 16</a> - triggers a <a href="Segmentation_fault" title="Segmentation fault">segmentation fault</a> when it detects use-after-free and <a href="Buffer_overflow" title="Buffer overflow">buffer overflow</a>.<a href="#cite_note-10">[10]</a><a href="#cite_note-11">[11]</a>

<ul><li><a href="Common_Vulnerabilities_and_Exposures" title="Common Vulnerabilities and Exposures">Common Vulnerabilities and Exposures</a></li>

<li><a href="Memory_debugger" title="Memory debugger">Memory debugger</a></li>

<li><a href="Wild_branch" title="Wild branch">Wild branch</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

<li id="cite_note-1"><a href="#cite_ref-1">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://gcc.gnu.org/onlinedocs/gcc-4.0.2/gcc/Warning-Options.html">"Warning Options - Using the GNU Compiler Collection (GCC)"</a>.</cite>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> Gianna Cioni, Antoni Kreczmar, Programmed deallocation without dangling reference, <a href="Information_Processing_Letters" title="Information Processing Letters">Information Processing Letters</a>, v. 18, 1984, pp. 179–185

</li>

<li id="cite_note-Fisher-3">^ <a href="#cite_ref-Fisher_3-0">a</a> <a href="#cite_ref-Fisher_3-1">b</a> C. N. Fisher, R. J. Leblanc, The implementation of run-time diagnostics in Pascal , <a href="IEEE_Transactions_on_Software_Engineering" title="IEEE Transactions on Software Engineering">IEEE Transactions on Software Engineering</a>, 6(4):313–319, 1980.

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite id="CITEREFDalcianonymous_authorCWE_Content_Team2012" class="citation web cs1">Dalci, Eric; anonymous author; CWE Content Team (May 11, 2012). <a rel="nofollow" class="external text" href="https://cwe.mitre.org/data/definitions/416.html">"CWE-416: Use After Free"</a>. Common Weakness Enumeration. <a href="Mitre_Corporation" title="Mitre Corporation">Mitre Corporation</a>. Retrieved April 28, 2014.</cite> <code class="cs1-code">{{cite web}}</code>: <code class="cs1-code">|author2=</code> has generic name (help)

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20170430095220/http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-1776">"CVE-2014-1776"</a>. Common Vulnerabilities and Exposures (CVE). 2014-01-29. Archived from <a rel="nofollow" class="external text" href="https://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-1776">the original</a> on 2017-04-30. Retrieved 2017-05-16.</cite>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> <cite id="CITEREFChenCaseldenScott2014" class="citation web cs1">Chen, Xiaobo; Caselden, Dan; Scott, Mike (April 26, 2014). <a rel="nofollow" class="external text" href="http://www.fireeye.com/blog/uncategorized/2014/04/new-zero-day-exploit-targeting-internet-explorer-versions-9-through-11-identified-in-targeted-attacks.html">"New Zero-Day Exploit targeting Internet Explorer Versions 9 through 11 Identified in Targeted Attacks"</a>. FireEye Blog. <a href="FireEye" class="mw-redirect" title="FireEye">FireEye</a>. Retrieved April 28, 2014.</cite>

</li>

<li id="cite_note-7"><a href="#cite_ref-7">^</a> <a rel="nofollow" class="external text" href="http://msdn2.microsoft.com/en-us/library/aa270812(VS.60).aspx">Visual C++ 6.0 memory-fill patterns</a>

</li>

<li id="cite_note-8"><a href="#cite_ref-8">^</a> <a rel="nofollow" class="external text" href="https://gcc.gnu.org/wiki/Mudflap_Pointer_Debugging">Mudflap Pointer Debugging</a>

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> Dhurjati, D. and Adve, V. <a rel="nofollow" class="external text" href="http://llvm.org/pubs/2006-DSN-DanglingPointers.pdf">Efficiently Detecting All Dangling Pointer Uses in Production Servers</a>

</li>

<li id="cite_note-10"><a href="#cite_ref-10">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://source.android.com/docs/security/test/memory-safety/arm-mte">"Arm memory tagging extension"</a>. Android Open Source Project. Retrieved 2025-06-11.</cite>

</li>

<li id="cite_note-11"><a href="#cite_ref-11">^</a> <cite id="CITEREFGoodin2025" class="citation web cs1">Goodin, Dan (2025-05-13). <a rel="nofollow" class="external text" href="https://arstechnica.com/security/2025/05/google-introduces-advanced-protection-mode-for-its-most-at-risk-android-users/">"Google introduces Advanced Protection mode for its most at-risk Android users"</a>. Ars Technica. Retrieved 2025-06-11.</cite>

</li>

</ol></div></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1236075235">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox" aria-labelledby="Memory_management1048" style="padding:3px"><table class="nowraplinks hlist mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><style data-mw-deduplicate="TemplateStyles:r1239400231">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div id="Memory_management1048" style="font-size:114%;margin:0 4em"><a href="Memory_management" title="Memory management">Memory management</a></div></th></tr><tr><td class="navbox-abovebelow" colspan="2"><div>

<ul><li><a href="Memory_management_(operating_systems)" title="Memory management (operating systems)">Memory management as a function of an operating system</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Hardware</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Memory_management_unit" title="Memory management unit">Memory management unit</a> (MMU)</li>

<li><a href="Translation_lookaside_buffer" title="Translation lookaside buffer">Translation lookaside buffer</a> (TLB)</li>

<li><a href="Input%E2%80%93output_memory_management_unit" title="Input–output memory management unit">Input–output memory management unit</a> (IOMMU)</li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Virtual_memory" title="Virtual memory">Virtual memory</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Demand_paging" title="Demand paging">Demand paging</a></li>

<li><a href="Memory_paging" title="Memory paging">Memory paging</a></li>

<li><a href="Page_table" title="Page table">Page table</a></li>

<li><a href="Virtual_memory_compression" title="Virtual memory compression">Virtual memory compression</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Memory_segmentation" title="Memory segmentation">Segmentation</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Protected_mode" title="Protected mode">Protected mode</a></li>

<li><a href="Virtual_8086_mode" title="Virtual 8086 mode">Virtual 8086 mode</a></li>

<li><a href="X86_memory_segmentation" title="X86 memory segmentation">x86 memory segmentation</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Memory_allocator" class="mw-redirect" title="Memory allocator">Allocator</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Dlmalloc" class="mw-redirect" title="Dlmalloc">dlmalloc</a></li>

<li><a href="Hoard_memory_allocator" title="Hoard memory allocator">Hoard</a></li>

<li><a href="Jemalloc" class="mw-redirect" title="Jemalloc">jemalloc</a></li>

<li><a href="Libumem" title="Libumem">libumem</a></li>

<li><a href="Mimalloc" title="Mimalloc">mimalloc</a></li>

<li><a href="Ptmalloc" class="mw-redirect" title="Ptmalloc">ptmalloc</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Manual_memory_management" title="Manual memory management">Manual</a> means</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Static_variable" title="Static variable">Static memory allocation</a></li>

<li><a href="C_dynamic_memory_allocation" title="C dynamic memory allocation">C dynamic memory allocation</a></li>

<li><a href="New_and_delete_(C%2B%2B)" title="New and delete (C++)">new and delete (C++)</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Garbage_collection_(computer_science)" title="Garbage collection (computer science)">Garbage collection</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Automatic_Reference_Counting" title="Automatic Reference Counting">Automatic Reference Counting</a></li>

<li><a href="Boehm_garbage_collector" title="Boehm garbage collector">Boehm garbage collector</a></li>

<li><a href="Cheney's_algorithm" title="Cheney's algorithm">Cheney's algorithm</a></li>

<li><a href="Concurrent_mark_sweep_collector" title="Concurrent mark sweep collector">Concurrent mark sweep collector</a></li>

<li><a href="Finalizer" title="Finalizer">Finalizer</a></li>

<li><a href="Garbage_(computer_science)" title="Garbage (computer science)">Garbage</a></li>

<li><a href="Garbage-first_collector" title="Garbage-first collector">Garbage-first collector</a></li>

<li><a href="Mark%E2%80%93compact_algorithm" title="Mark–compact algorithm">Mark–compact algorithm</a></li>

<li><a href="Reference_counting" title="Reference counting">Reference counting</a></li>

<li><a href="Tracing_garbage_collection" title="Tracing garbage collection">Tracing garbage collection</a></li>

<li><a href="Weak_reference" title="Weak reference">Strong reference</a></li>

<li><a href="Weak_reference" title="Weak reference">Weak reference</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Memory_safety" title="Memory safety">Safety</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Buffer_overflow" title="Buffer overflow">Buffer overflow</a></li>

<li><a href="Buffer_over-read" title="Buffer over-read">Buffer over-read</a></li>

<li><a href="Stack_overflow" title="Stack overflow">Stack overflow</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Issues</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Fragmentation_(computing)" title="Fragmentation (computing)">Fragmentation</a></li>

<li><a href="Memory_leak" title="Memory leak">Memory leak</a></li>

<li><a href="Unreachable_memory" title="Unreachable memory">Unreachable memory</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Other</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Automatic_variable" title="Automatic variable">Automatic variable</a></li>

<li><a href="International_Symposium_on_Memory_Management" title="International Symposium on Memory Management">International Symposium on Memory Management</a></li>

<li><a href="Region-based_memory_management" title="Region-based memory management">Region-based memory management</a></li>

<li><a href="Memory_pool" title="Memory pool">Memory pool</a></li></ul>

</div></td></tr><tr><td class="navbox-abovebelow" colspan="2"><div>

<ul><li> Memory management</li>

<li> Virtual memory</li>

<li> Automatic memory management</li>

<li> Memory management algorithms</li>

<li> Memory management software</li></ul>

</div></td></tr></tbody></table></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-08-01" href="https://en.wikipedia.org/wiki/?title=Dangling_pointer&oldid=1303760219">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>